﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NCmd;

// 客户端接口定义
public interface IClient
{
    bool Connect(Action sc, Action fc);
    void SendCmd(Cmd cmd);
    void Recive(Cmd cmd);
}


// 网络连接处理类
public class Net : Singleton<Net>, IClient
{
    //Server _server;

    // 消息类型与消息解析函数的对应关系
    Dictionary<Type, Action<Cmd>> _cmdParser = new Dictionary<Type, Action<Cmd>>();

    // 缓存消息，待以后处理
    List<Cmd> _cmdCache = new List<Cmd>();

    // 消息处理是否是“阻塞状态”
    public bool _isPause = false;

    public bool IsPause
    {
        set
        {
            _isPause = value;
            if (_isPause == false)
            {
                Recive();
            }
        }

        get { return _isPause; }
    }

    public Net()
    {
        // 必须先注册消息解析函数
        RegistCmdParser();
    }

    // 注册消息解析函数
    public void RegistCmdParser()
    {
        _cmdParser.Add(typeof(NCmd.RoleList), SelectRoleMgr.OnRoleList);
        _cmdParser.Add(typeof(NCmd.LoadMap), SceneMgr.OnLoadMap);
        _cmdParser.Add(typeof(NCmd.MainRoleThisid), RoleMgr.OnMainRoleThisId);
        _cmdParser.Add(typeof(NCmd.AddSceneRole), RoleMgr.OnAddSceneRole); 
        _cmdParser.Add(typeof(NCmd.AddSceneNpc), NpcMgr.OnAddSceneNpc);
    }


    // 连接服务器
    public bool Connect(Action SuccessCallback, Action FailedCallback)
    {
        //_server = Server.Instance;
        //_server.Connect(this);

        bool connectSuccess = true; ;
        if (connectSuccess)
        {
            if (SuccessCallback != null) { SuccessCallback(); }
        }
        else
        {
            if (FailedCallback != null) { FailedCallback(); }
        }


        return true;
    }

    // 向服务器发送消息
    public void SendCmd(Cmd cmd)
    {
        //_server.Recive(cmd);
    }

    // 接收到消息，分发消息
    public void Recive(Cmd cmd = null)
    {
        // 缓存消息
        if (cmd != null)
        {
            _cmdCache.Add(cmd);
        }

        // 判断是否阻塞，阻塞则返回
        if (IsPause) { return; }

        doCachedCmd();
    }

    // 处理缓存中的消息
    private void doCachedCmd()
    {
        // 处理已缓存的消息
        foreach (var cachedCmd in _cmdCache)
        {
            var cmdType = cachedCmd.GetType();

            Action<Cmd> cmdParser;
            if (_cmdParser.TryGetValue(cmdType, out cmdParser))
            {
                if (cmdParser != null) { cmdParser(cachedCmd); }
            }
        }
        _cmdCache.Clear();
    }

}
